////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  Filename:    BigShotGuts.cpp                                              //
//  Developer:   Omar Segura                                                  //
//  Create date: 09/07/2007                                                   //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//  Description: This is the class implementation for the slot gut of the     //
//               Australian Slot machine called BigShot .                     //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////
//        Copyright (c) 2007 - Realtime Gaming.  All rights reserved.         //
////////////////////////////////////////////////////////////////////////////////

#include "BigShotGuts.h"

////////////////////////////////////////////////////////////////////////////
/// BigShotGuts::m_aLineWinSpinResults
///
/// This array is used to quickly get the SpinResult for the number of
/// icons.  It is indexed by wheel icon and then count.  So to get the
/// SpinResult for 5 Aces, use the following code snippet:
///
///		SpinResult result = m_aLineWinSpinResults[ ICON_ACE ][ 5 ];
///
/// In this example result would be set to EVT_FIVE_ACE.
////////////////////////////////////////////////////////////////////////////
BigShotGuts::SpinResult BigShotGuts::m_aLineWinSpinResults[][6] = 
{
// Number of icons:			0			1					2						3						4						5
/* ICON_NINE */			{	EVT_LOSER,	EVT_LOSER,			EVT_LOSER,				EVT_THREE_NINE,			EVT_FOUR_NINE,			EVT_FIVE_NINE,			},
/* ICON_TEN */			{	EVT_LOSER,	EVT_LOSER,			EVT_LOSER,				EVT_THREE_TEN,			EVT_FOUR_TEN,			EVT_FIVE_TEN,			},
/* ICON_JACK */			{	EVT_LOSER,	EVT_LOSER,			EVT_LOSER,				EVT_THREE_JACK,			EVT_FOUR_JACK,			EVT_FIVE_JACK,			},
/* ICON_QUEEN */		{	EVT_LOSER,	EVT_LOSER,			EVT_LOSER,				EVT_THREE_QUEEN,		EVT_FOUR_QUEEN,			EVT_FIVE_QUEEN,			},
/* ICON_KING */			{	EVT_LOSER,	EVT_LOSER,			EVT_LOSER,				EVT_THREE_KING,			EVT_FOUR_KING,			EVT_FIVE_KING,			},
/* ICON_ACE */			{	EVT_LOSER,	EVT_LOSER,			EVT_LOSER,				EVT_THREE_ACE,			EVT_FOUR_ACE,			EVT_FIVE_ACE,			},
/* ICON_CLAPPER */		{	EVT_LOSER,	EVT_LOSER,			EVT_TWO_CLAPPER,		EVT_THREE_CLAPPER,		EVT_FOUR_CLAPPER,		EVT_FIVE_CLAPPER,		},
/* ICON_MOVIE_REEL */	{	EVT_LOSER,	EVT_LOSER,			EVT_TWO_MOVIE_REEL,		EVT_THREE_MOVIE_REEL,	EVT_FOUR_MOVIE_REEL,	EVT_FIVE_MOVIE_REEL,	},
/* ICON_SPORTS_CAR */	{	EVT_LOSER,	EVT_LOSER,			EVT_TWO_SPORTS_CAR,		EVT_THREE_SPORTS_CAR,	EVT_FOUR_SPORTS_CAR,	EVT_FIVE_SPORTS_CAR,	},
/* ICON_WOMAN */		{	EVT_LOSER,	EVT_LOSER,			EVT_TWO_WOMAN,			EVT_THREE_WOMAN,		EVT_FOUR_WOMAN,			EVT_FIVE_WOMAN,			},
/* ICON_SUPERSTAR */	{	EVT_LOSER,	EVT_LOSER,			EVT_LOSER,				EVT_LOSER,				EVT_LOSER,				EVT_LOSER,				},
/* ICON_AWARD */		{	EVT_LOSER,	EVT_LOSER,			EVT_LOSER,				EVT_LOSER,				EVT_LOSER,				EVT_LOSER,				},
/* ICON_BIG_SHOT */		{	EVT_LOSER,	EVT_ONE_BIG_SHOT,	EVT_LOSER,				EVT_LOSER,				EVT_LOSER,				EVT_LOSER,				}
};


////////////////////////////////////////////////////////////////////////////
/// BigShotGuts::m_aScatterWinSpinResults
///
/// This array is used to quickly get the SpinResult for the number of
/// icons.  It is indexed by icon count only, since Awards are the only
/// scatter win.  So to get the SpinResult for 5 Awards, use the
/// following code snippet:
///
///		SpinResult result = m_aScatterWinSpinResults[ 5 ];
///
/// In this example result would be set to EVT_FIVE_AWARD.
////////////////////////////////////////////////////////////////////////////
BigShotGuts::SpinResult BigShotGuts::m_aScatterWinSpinResults[6] = 
{
	// ICON_FLAG        Number of Icons
	EVT_LOSER,			// 0
	EVT_LOSER,			// 1
	EVT_TWO_AWARD,		// 2
	EVT_THREE_AWARD,	// 3
	EVT_FOUR_AWARD,		// 4
	EVT_FIVE_AWARD		// 5
};

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::BigShotGuts()   
///
/// This is the default constructor for the class.
////////////////////////////////////////////////////////////////////////////
BigShotGuts::BigShotGuts()
{
	// If this doesn't compile it means that someone probably added
	// another icon type but did not update the
	// m_aLineWinSpinResults array. 
	C_ASSERT( countof( m_aLineWinSpinResults ) == NUM_VALID_ICONS );
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::~BigShotGuts()
///
/// Destructor for BigShotGuts. 
////////////////////////////////////////////////////////////////////////////
BigShotGuts::~BigShotGuts()
{
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 MermaidQueenGuts::getNumScatterIcons()   
///
/// @param   spin				The current spin object.
/// @param   nIconType			The icon type we are looking for.
/// @param   scatterPositions	The bit mask for the scatters positions that we find.
///
/// @return	 uint8				The number of scatter icons that we find.
///
/// This helper method is used to count the number of scatter icons.
////////////////////////////////////////////////////////////////////////////
uint8 BigShotGuts::getNumScatterIcons( SlotSpin* spin, uint8 nIconType, 
	int32& scatterPositions ) const
{	
	// Keep up with how many scatter icons we found.
	uint8 numScatterIcons = 0;

	// Loop through each reel.
  	for( int reel = 0; reel < getReelCount(); reel++ )
	{
		// The position bit for the current icon in case it needs to be stored in a mask.
		uint8 position = reel;

		// Loop through each row in the wheel house.
		for( int row = 0; row < 3; row++ )
		{
			// Get the current stop.
			uint8 stop = relativeWheelPosition( getGameModeId(), reel,
				spin->getStops()[ reel ], row );

			// Get the icon for the current stop.
			uint8 currentIcon = getIcon( getGameModeId(), reel, stop )->iconid;
			
			// If the icon is the one we are looking for...
			if ( currentIcon == nIconType )
			{
				// then increase the scatter icon count
				numScatterIcons++;

				// Set the bit in the position mask for this stop.
				scatterPositions |= 1 << position;
			}

			// Move to the next bit in the position mask.
            position += 5;
		}
	}

	// Return the number of icons that we found.
	return numScatterIcons;
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 SpinResult BigShotGuts::getFreeGameWinResult( SlotSpin* spin, int32& featurePositions )
///
/// @param   spin				The current spin object.
/// @param   featurePositions	The bit mask for the scatter positions that we find.
///
/// @return	 SpinResult			A payout from the SpinResult enumeration.
///
/// This helper method is used to determine if the free game is won.
////////////////////////////////////////////////////////////////////////////
BigShotGuts::SpinResult BigShotGuts::getFreeGameWinResult( SlotSpin* spin, int32& featurePositions ) const
{
	// Count the number of Bigshot icons.
	uint8 nCount = getNumScatterIcons( spin, ICON_BIG_SHOT, featurePositions );

	if ( getGameModeId() == MODE_NORMAL )
	{
		if ( nCount == 2 )
		{
			return EVT_FREE_GAME_FEATURE;
		}
		else if ( nCount == 1 )
		{
			return EVT_FEATURE_NEAR_MISS;
		}
	}

	return EVT_LOSER;
}


////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::isSubstitute( uint8 icon )
///
/// @param   icon			Icon to test for substitute
///
/// @return	 bool			true if the icon is substitute for the game mode, 
///							otherwise it returns false.
///
/// This helper method is used to determine if an icon is substitute
/// for the current game mode.
////////////////////////////////////////////////////////////////////////////
bool 
BigShotGuts::isSubstitute( uint8 icon ) const
{
	if ( icon == ICON_SUPERSTAR )
	{
		// superstar is always substitute
		return true;
	}
	else if ( icon == ICON_BIG_SHOT && getGameModeId() == MODE_FREE_SPIN )
	{
		return true;
	}

	return false;
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::SpinResult BigShotGuts::getSubstituteStripPayout( uint8* stops ) const
///
/// @param   stops			The array of stop positions for the line.
///
/// @return	 SpinResult		A payout from the SpinResult enumeration.
///
/// This helper method is used to calculate the line win payout of womans formed
/// only by substitutes.
/// Eg: Big Shot SuperStar SuperStar SuperStar Ace could be interpreted as 4 Woman which pays 500 
/// or 5 Ace which pays 400 or 1 Bigshot which pays 2 (or in fact any other 4, 3, or 2 of a kind 
/// since there are 4 substitutes but all these, including 1 Big Shot, pay less than 4 Woman). 
/// Therefore it pays as 4 Woman since only the highest win pays on each line.
////////////////////////////////////////////////////////////////////////////
BigShotGuts::SpinResult BigShotGuts::getSubstituteStripPayout( uint8* stops ) const
{
	int nSubstituteCount = 0;

	// If we are not in free spin mode then there are no substitutes on first reel,
	// therefore we can't hay a payout formed by substitues only.
	if ( getGameModeId() != MODE_FREE_SPIN )
	{
		return EVT_LOSER;
	}
	
	for ( int i = 0; i < getReelCount(); i++ )
	{
		// See what this icon is.
		uint8 icon = getIcon( getGameModeId(), i, stops[i] )->iconid;

		if ( isSubstitute( icon) )
		{
			nSubstituteCount++;
		}
		else
		{
			break;
		}
	}

	// Use the Woman icon to get the payout since woman is the icon
	// that pays more.
	return lookupLineWinSpinResult( ICON_WOMAN, nSubstituteCount );
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::SpinResult BigShotGuts::getLineWinResultWithPossibleSubstitution( uint8* stops, uint8 testIcon, bool& bSubstitution ) const
///
/// @param   stops			The array of stop positions for the line.
/// @param   testIcon		The icon we are looking for, typically the first icon on the line.
/// @param   bSubstitution	An output parameter that is set if a subsitution is used.
///
/// @return	 SpinResult		A payout from the SpinResult enumeration.
///
/// This helper method is used to calculate the line win payout with a possible substitution.
////////////////////////////////////////////////////////////////////////////
BigShotGuts::SpinResult BigShotGuts::getLineWinResultWithPossibleSubstitution(
	uint8* stops, uint8 testIcon, bool& bSubstitution ) const
{
	// Flag to indicate that this line starts with a bigshot
	// Needed during free games when BigShot is substitute
	bool bStartsWithBigShot = false;

	// Initialize the out parameter
	bSubstitution = false;

	if ( testIcon == ICON_SUPERSTAR )
	{
		// SuperStar does not appear on first reel so this should
		// never happen.
		ASSERT( false );
	}

	if ( testIcon == ICON_BIG_SHOT && getGameModeId() == MODE_FREE_SPIN )
	{
		// This is a line for free games and starts with a big shot.
		bStartsWithBigShot = true;
	}

	// Loop through the remaining reels until the streak is over
	for ( int i = 1; i < getReelCount(); i++ )
    {		
		if ( testIcon == ICON_BIG_SHOT && getGameModeId() == MODE_NORMAL )
		{
			// BigShot is not substituted
			break;
		}		

		// See what this icon is.
		uint8 currentIcon = getIcon( getGameModeId(), i, stops[i] )->iconid;
				
		if ( isSubstitute( testIcon ) )
		{
			bSubstitution = true;
			testIcon = currentIcon;
			continue;
		}
		else if ( isSubstitute( currentIcon ) )
		{
			bSubstitution = true;
			continue;
		}

		// If the current icon is not the test icon...
        if ( currentIcon != testIcon )
        {
			// then the streak is over so break out of the loop
			break;
        }
    }

	SpinResult result;

	// Use the array to look up the spin result for i testIcons.
	SpinResult resultNormal     = lookupLineWinSpinResult( testIcon, i );

	// Get the spin result interpreting substitues as womans
	SpinResult resultSubstitue  = getSubstituteStripPayout( stops );

	if ( getPayout( resultNormal )->payoutAmount > getPayout( resultSubstitue )->payoutAmount )
	{
		result = resultNormal;
	}
	else
	{
		result = resultSubstitue;
	}

	if ( result == EVT_LOSER && bStartsWithBigShot )
	{
		// It was loser result using bigshot as bustitute. But since line
		// started with a BigShot then we return prize for one BigShot
		result = lookupLineWinSpinResult( ICON_BIG_SHOT, 1 );
		bSubstitution = false;
	}

	return result;
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::classifyStops()   
///
/// @param   stops      The array of stop positions for the line.
/// @param   bet        The value of the line bet.
/// @param   line       The index of the line.
///
/// @return	 uint8      A payout from the SpinResult enumeration as a uint8.    
///
/// This helper method is used to calculate the payout on a line.
////////////////////////////////////////////////////////////////////////////
void BigShotGuts::classifyStops( SpinLine* spinline, uint8* stops, uint8 bet, uint8 line,
	uint8& rtnresult, uint8& multiplier )
{
	// See what the payout is if we use any SuperStar we find as substitution symbols.
	// Start with the icon on the first reel.
	uint8 testIcon = getIcon( getGameModeId(), 0, stops[0] )->iconid;

	// Declare a local variable to track whether or not we found a substitution.
	bool bSubstitution = false;

	// See what the spin result is if we used any ships as substitution symbols.
	rtnresult =	getLineWinResultWithPossibleSubstitution( stops, testIcon, bSubstitution );

	// If we did actually have a substitution and a winning spin...
	if ( bSubstitution && rtnresult != EVT_LOSER )
	{
		spinline->addNote( NOTE_SUBSTITUTION );
	}
}



////////////////////////////////////////////////////////////////////////////
/// @fn		BigShotGuts::tryForJackpot()
///
///	This function looks to see if we hit the jackpot.
////////////////////////////////////////////////////////////////////////////
void BigShotGuts::tryForJackpot( SlotSpin* spin )
{
	// If we are in the first paid spin (NOT a bonus spin)...
	if ( getGameModeId() == MODE_NORMAL ) 
	{
		// then try for the Random Progressive Jackpot
		// If we hit the jackpot...
		if ( getRandomProgressiveJackpotResult( getNumLinesBet() ) || 
             m_bForceRandomJackpot == true )
		{
			// then add a jackpot scatter to the spin.
			spin->addScatter( 0,
				getPayout( EVT_RANDOM_PROGRESSIVE_WINNER )->payoutAmount, 1,
				true, EVT_RANDOM_PROGRESSIVE_WINNER, 0 );
		}
    }
}



////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::getScatterWinResult()   
///
/// @param   spin						The current spin object.
/// @param   nNumScatterIcons			The number of scatter icons that we find.
/// @param   nScatterPositions			The bit mask for the scatters positions that we find.
///
/// @return	 SpinResult					A payout from the SpinResult enumeration.
///
/// This helper method is used to evaluate the spin for scatters.
////////////////////////////////////////////////////////////////////////////
BigShotGuts::SpinResult BigShotGuts::getScatterWinResult( SlotSpin* spin, int32& nNumScatterIcons,
	int32& nScatterPositions) const
{
	// Count the number of Clam icons.
	uint8 nCount = getNumScatterIcons( spin, ICON_AWARD, nScatterPositions );

	// Use the array to look up the spin result for nNumScatterIcons.
	return lookupScatterWinSpinResult( nCount );
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::addScatterWin()
///
/// This function determines if the current spin wins a scatter payment and
/// adds the scatter.
////////////////////////////////////////////////////////////////////////////
void BigShotGuts::addScatterWin( SlotSpin* spin, SpinResult srScatterResult, 
	int32 nScatterPositions )
{
	// If we got the scatter win...
	if ( srScatterResult != EVT_LOSER )
	{	
		// then initialize our multiplier for scatters.
		int32 multiplier = 1;

		// If we are in free spin mode...
		if ( getGameModeId() == MODE_FREE_SPIN )
		{
			// then use the free spin scatter multiplier.
			multiplier = this->getNumSpinsSinceFirstTrigger();
		}

		// Get the base payout for the scatter.
		int32 nPayout = getPayout( srScatterResult )->payoutAmount;
		
		// Scatters payout based on the total bet, so factor in the number of bet lines.
		nPayout *= spin->getSpinLineCount();

		// Add the payout (with multiplier) to the total win for this spin.
		increaseTotalWin( nPayout * multiplier );
    
		// Add a scatter to the spin.
		SlotScatter* pScatter = spin->addScatter( nScatterPositions,
			nPayout * getBetPerLine(), multiplier, false, srScatterResult, 0 );

		// If we are in free spin mode...
		if ( getGameModeId() == MODE_FREE_SPIN )
		{
			pScatter->addNote( NOTE_FREE_SPIN );
		}
	}
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::addFeatureTrigger()
///
/// This function determines if the current spin triggered the free game
/// feature and set the correct number of free spins.
////////////////////////////////////////////////////////////////////////////
void BigShotGuts::addFeatureTrigger( SlotSpin* spin, SpinResult srFeatureTriggerResult, 
	int32 featurePositions )
{
	if ( getGameModeId() == MODE_FREE_SPIN )
	{
		//No additional free games can be won during the free game.
		return;
	}

	// We need a place to keep up with how many free spins to award.
	int32 nFreeSpins = 0;

	// Figure out how many free spins they get.
	if ( srFeatureTriggerResult == EVT_FREE_GAME_FEATURE )
	{
		nFreeSpins = getRandomValueFromProbabilityTable( TBL_FREE_GAMES_AWARDED );

		// If they get free spins...
		if ( nFreeSpins )
		{
			// Reset the number of free spins.
			setNumSpinsSinceFirstTrigger( 0 );

			// then change the game mode.
			setGameModeId( MODE_FREE_SPIN );

			// Add the free spins.
			incrementFreeSpins( nFreeSpins );
		}
	}
	else if ( srFeatureTriggerResult == EVT_LOSER )
	{
		return;
	}

	// Add a scatter to the spin for the feature trigger.
	spin->addScatter( featurePositions, 0, 0, false,
		srFeatureTriggerResult, nFreeSpins );
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::classifyScatters( SlotSpin* spin )
///
/// @param   spin       Pointer to the spin with stop data.
///
/// This is an override of the framework method.  
/// It determines if the current spin merits free spins or scatter payments.
////////////////////////////////////////////////////////////////////////////
void BigShotGuts::classifyScatters( SlotSpin* spin )
{
	// Try for the Random Progressive Jackpot
	tryForJackpot( spin );

	// Declare some local variables to track the scatter positions.
	int32 nScatterPositions = 0;
	int32 nNumScatterIcons  = 0;

	// See if there is a scatter win.
	SpinResult srResult = getScatterWinResult( spin, nNumScatterIcons, nScatterPositions);

	// Add the scatter, if any.
	addScatterWin( spin, srResult, nScatterPositions);

	// Declare a local variable to track the feature positions.
	int32 nFeaturePositions = 0;

	// See if there is a feature trigger.
	SpinResult srFeatureTriggerResult = getFreeGameWinResult( spin, nFeaturePositions );

	// Add the scatters for the free game feature or near miss.
	addFeatureTrigger( spin, srFeatureTriggerResult, nFeaturePositions );
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::isValidGuts()   
///
/// @return	 bool8      True if gut is valid.    
///
/// This helper method is used to see if the current gut ID is valid.
////////////////////////////////////////////////////////////////////////////
bool8 BigShotGuts::isValidGuts()
{
	// Make sure that the m_aLineWinSpinResults array has an entry for each reel,
	// and an additional entry in case there are 0 icons on the line.
	// Note:  we can't do this in the constructor because we have to call
	// getReelCount.
	ASSERT( countof( m_aLineWinSpinResults[0] ) == getReelCount( MODE_NORMAL ) + 1 );

	// Make sure that the m_aScatterWinSpinResults array has an entry for each reel,
	// and an additional entry in case there are 0 icons on the line.
	ASSERT( countof( m_aScatterWinSpinResults ) == getReelCount( MODE_NORMAL ) + 1 );

	// Now make sure that all game modes have the same number of reels.
	ASSERT( getReelCount( MODE_NORMAL ) == getReelCount( MODE_FREE_SPIN ) );

	// Finally just check to see if the gut is within the right range.
    return ( getGutsId() >= 4000 && getGutsId() < 4100 );
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::getGameModeMultiplierAndNoteId( uint8& nGameModeMultiplier, uint8& nNoteId )
///
/// @param   nGameModeMultiplier	The multiplier for the game mode.
/// @param   nNoteId				The note ID for the game mode.
///
/// This helper method is used to get the game mode multiplier and note ID.
////////////////////////////////////////////////////////////////////////////
void BigShotGuts::getGameModeMultiplierAndNoteId( uint8& nGameModeMultiplier,
	uint8& nNoteId )
{
	// If we are in free spin mode...
    if ( getGameModeId() == MODE_FREE_SPIN )
    {
		// then return the free spin multiplier...
        nGameModeMultiplier = getNumSpinsSinceFirstTrigger();

		// and the free spin note.
        nNoteId = NOTE_FREE_SPIN;
    }
	// Otherwise...
    else
    {
		// just defer to the base class.
        SlotGuts::getGameModeMultiplierAndNoteId( nGameModeMultiplier, nNoteId );
    }
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::setNumSpinsSinceFirstTrigger(int32 nNumSpinsSinceFirstTrigger) 
///
/// @param   nFeatureTriggerCount    The number of spins since the first trigger..
///
/// This is an accessor to return the number of spins since the first trigger..
////////////////////////////////////////////////////////////////////////////
void 
BigShotGuts::setNumSpinsSinceFirstTrigger(int32 nNumSpinsSinceFirstTrigger)
{
    m_subGame->update( SGDIDX_NUM_SPINS_SINCE_FIRST_TRIGGER, nNumSpinsSinceFirstTrigger );
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::getNumSpinsSinceFirstTrigger() const   
///
/// @return  int32   The number of spins since the first trigger.
///
/// This is a mutator method to change the number of spins since the first trigger.
////////////////////////////////////////////////////////////////////////////
int32 
BigShotGuts::getNumSpinsSinceFirstTrigger() const
{
    return m_subGame->getData( SGDIDX_NUM_SPINS_SINCE_FIRST_TRIGGER );
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::preSpinClassifyResults()   
///
/// @param   spin       Pointer to the spin with stop data.
///
/// Sets the number of free spins in SubGame data.
////////////////////////////////////////////////////////////////////////////
void BigShotGuts::preSpinClassifyResults( SlotSpin* spin )
{
	SlotGuts::preSpinClassifyResults(spin);

    if ( getGameModeId() == MODE_FREE_SPIN )
    {
        setNumSpinsSinceFirstTrigger( getNumSpinsSinceFirstTrigger()+1 );
	}
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 BigShotGuts::Debug_SetLoserStops( uint8* pStops )
///
/// @param   pStops		The stops to set.
///
/// Base class override, returns a losing spin triggered by the debug tool
////////////////////////////////////////////////////////////////////////////
void BigShotGuts::Debug_SetLoserStops( uint8* pStops )
{
	pStops[0]=3;
	pStops[1]=3;
	pStops[2]=3;
	pStops[3]=3;
	pStops[4]=3;
}
